// 系统菜单主文件
import fs from 'node:fs/promises'
import path from 'node:path'
import { segment } from 'oicq'
import Renderer from '../../../lib/renderer/Renderer.js'
import cfg from '../../../lib/config/config.js'

// 创建渲染器实例
const renderer = new Renderer({ id: 'menuRenderer', type: 'image' })

// 菜单配置路径
const configPath = path.join(process.cwd(), 'plugins', 'systemDB', 'menu', 'config.yaml')
// 菜单模板路径
const templatePath = path.join(process.cwd(), 'plugins', 'systemDB', 'resources', 'menu.html')

// 菜单管理器
class MenuManager {
  constructor() {
    this.plugins = [] // 存储插件信息
    this.menus = [] // 存储菜单配置
    this.config = {} // 初始化配置
    this.categories = {} // 存储分类信息
  }

  // 初始化菜单
  async init() {
    // 确保配置目录存在
    await fs.mkdir(path.dirname(configPath), { recursive: true })

    // 检查配置文件是否存在，如果不存在则创建默认配置
    try {
      await fs.access(configPath)
    } catch {
      await this.createDefaultConfig()
    }

    // 加载配置
    await this.loadConfig()

    // 确保模板文件存在
    try {
      await fs.access(templatePath)
    } catch {
      await this.createDefaultTemplate()
    }
  }

  // 创建默认配置
  async createDefaultConfig() {
    const defaultConfig = {
      menu: {
        title: '插件菜单',
        description: '这里是所有可用插件的菜单列表',
        showIcon: true,
        iconSize: 48,
        pluginsPerPage: 10,
        backgroundColor: '#f5f5f5',
        textColor: '#333333',
        accentColor: '#4CAF50',
        fontFamily: 'Microsoft YaHei'
      }
    }

    // 使用 yaml 模块将配置转换为字符串
    const yaml = await import('yaml')
    const configStr = yaml.stringify(defaultConfig)

    // 写入配置文件
    await fs.writeFile(configPath, configStr, 'utf8')
    // 移除日志输出
  }

  // 创建默认模板
  async createDefaultTemplate() {
    const defaultTemplate = `<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>{{ menu.title }}</title>
  <style>
    body {
      font-family: {{ menu.fontFamily }};
      background-color: {{ menu.backgroundColor }};
      color: {{ menu.textColor }};
      margin: 0;
      padding: 20px;
    }
    .container {
      max-width: 800px;
      margin: 0 auto;
      background-color: white;
      border-radius: 10px;
      padding: 20px;
      box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
    }
    h1 {
      color: {{ menu.accentColor }};
      text-align: center;
      margin-bottom: 10px;
    }
    .description {
      text-align: center;
      margin-bottom: 20px;
      color: #666;
    }
    .plugin-list {
      display: grid;
      grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
      gap: 15px;
    }
    .plugin-item {
      border: 1px solid #ddd;
      border-radius: 8px;
      padding: 15px;
      transition: all 0.3s ease;
      cursor: pointer;
    }
    .plugin-item:hover {
      transform: translateY(-3px);
      box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
      border-color: {{ menu.accentColor }};
    }
    .plugin-icon {
      width: {{ menu.iconSize }}px;
      height: {{ menu.iconSize }}px;
      margin: 0 auto 10px;
      display: block;
    }
    .plugin-name {
      font-weight: bold;
      text-align: center;
      margin-bottom: 5px;
    }
    .plugin-desc {
      font-size: 14px;
      color: #666;
      text-align: center;
    }
    .page-info {
      text-align: center;
      margin-top: 20px;
      color: #666;
    }
  </style>
</head>
<body>
  <div class="container">
    <h1>{{ menu.title }}</h1>
    <div class="description">{{ menu.description }}</div>
    <div class="plugin-list">
      {{#each plugins}}
      <div class="plugin-item" data-index="{{ @index }}">
        {{#if ../menu.showIcon}}
        <img class="plugin-icon" src="" alt="插件图标">
        {{/if}}
        <div class="plugin-name">{{ @index }}. {{ this.name }}</div>
        <div class="plugin-desc">{{ this.dsc }}</div>
      </div>
      {{/each}}
    </div>
    <div class="page-info">第 {{ page }}/{{ totalPages }} 页</div>
  </div>
</body>
</html>`

    await fs.writeFile(templatePath, defaultTemplate, 'utf8')
    // 移除日志输出
  }

  // 加载配置
  async loadConfig() {
    try {
      const yaml = await import('yaml')
      const configStr = await fs.readFile(configPath, 'utf8')
      this.config = yaml.parse(configStr)
      // 移除成功日志
    } catch (error) {
      // 移除错误日志
      this.config = {}
    }
  }

  // 渲染主菜单
  async renderMainMenu(e) {
    try {
      // 确保配置已加载
      if (!this.config || !this.config.menu) {
        await this.loadConfig()
        // 如果加载后仍然没有menu配置，使用默认值
        if (!this.config.menu) {
          this.config.menu = {
            title: '插件菜单',
            description: '这里是所有可用插件的菜单列表',
            showIcon: true,
            iconSize: 48,
            pluginsPerPage: 10,
            backgroundColor: '#f5f5f5',
            textColor: '#333333',
            accentColor: '#4CAF50',
            fontFamily: 'Microsoft YaHei'
          }
        }
      }

      // 更新分类信息
      this.updateCategories()

      // 获取所有分类
      const categories = this.getCategories()

      // 准备模板数据
      const data = {
        menu: this.config.menu,
        categories: categories,
        // 按分类组织插件
        pluginsByCategory: this.categories,
        page: 1
      }

      // 准备模板数据
      const tplData = {
        tplFile: path.join(process.cwd(), 'plugins', 'systemDB', 'resources', 'menu.html'),
        saveId: 'mainMenu',
        ...data
      }

      // 渲染HTML
      const htmlPath = await renderer.dealTpl('menu', tplData)
      const html = await fs.readFile(htmlPath, 'utf8')

      // 将HTML转换为图片
      const image = await this.htmlToImage(html)

      // 发送图片
      await e.reply([segment.image(image)])
    } catch (error) {
      // 移除错误日志
      await e.reply('菜单加载失败，请稍后再试')
    }
  }

  // 根据名称查找插件
  findPluginByName(name) {
    return this.menus.find(plugin =>
      plugin.name.toLowerCase().includes(name.toLowerCase()) ||
      plugin.dsc.toLowerCase().includes(name.toLowerCase())
    )
  }

  // 渲染插件详情
  async renderPluginDetail(e, identifier) {
    try {
      let plugin

      // 判断identifier是数字还是名称
      if (!isNaN(parseInt(identifier))) {
        // 按数字索引查找
        this.plugins = this.getPluginsList()
        plugin = this.plugins[parseInt(identifier) - 1]  // 转为从0开始的索引
      } else {
        // 按名称查找
        plugin = this.findPluginByName(identifier)
      }

      if (!plugin) {
        await e.reply('未找到该插件')
        return
      }

      // 确保配置已加载
      if (!this.config || !this.config.menu) {
        await this.loadConfig()
        // 如果加载后仍然没有menu配置，使用默认值
        if (!this.config.menu) {
          this.config.menu = {
            title: '插件菜单',
            description: '这里是所有可用插件的菜单列表',
            showIcon: true,
            iconSize: 48,
            pluginsPerPage: 10,
            backgroundColor: '#f5f5f5',
            textColor: '#333333',
            accentColor: '#4CAF50',
            fontFamily: 'Microsoft YaHei'
          }
        }
      }

      // 准备模板数据
      const data = {
        menu: this.config.menu,
        plugin: plugin
      }

      // 准备模板数据
      const tplData = {
        tplFile: path.join(process.cwd(), 'plugins', 'systemDB', 'resources', 'pluginDetail.html'),
        saveId: 'pluginDetail',
        ...data
      }

      // 渲染HTML
      const htmlPath = await renderer.dealTpl('pluginDetail', tplData)
      const html = await fs.readFile(htmlPath, 'utf8')

      // 将HTML转换为图片
      const image = await this.htmlToImage(html)

      // 发送图片
      await e.reply([segment.image(image)])
    } catch (error) {
      // 移除错误日志
      await e.reply('插件详情加载失败，请稍后再试')
    }
  }

  // 处理菜单命令
  async handleMenuCommand(e, command) {
    // 解析命令参数
    const params = command.trim().split(/\s+/)
    params.shift()  // 移除命令前缀 '#菜单'

    if (params.length === 0) {
      // 没有参数，显示主菜单
      await this.renderMainMenu(e)
    } else {
      // 有参数，显示插件详情
      await this.renderPluginDetail(e, params.join(' '))
    }
  }

  // 获取插件列表
  getPluginsList(category = null) {
    // 如果指定了分类，返回该分类下的插件
    if (category) {
      return this.categories[category] || []
    }
    // 否则返回所有插件
    return this.menus || []
  }

  // 获取所有分类
  getCategories() {
    return Object.keys(this.categories)
  }

  // HTML转图片
  async htmlToImage(html) {
    // 使用puppeteer将HTML转换为图片
    const puppeteer = await import('puppeteer')
    const browser = await puppeteer.launch()
    const page = await browser.newPage()

    // 设置页面内容
    await page.setContent(html)

    // 设置视口大小
    await page.setViewport({ width: 800, height: 600 })

    // 截图
    const buffer = await page.screenshot({
      fullPage: true,
      type: 'jpeg'
    })

    await browser.close()
    return buffer
  }

  // 注册插件菜单
  async registerPluginMenu(pluginInfo) {
    // 检查菜单配置是否已加载
    if (!this.config) {
      await this.loadConfig()
    }

    // 确保插件信息有分类，如果没有指定则默认为'功能'
    if (!pluginInfo.category) {
      pluginInfo.category = '功能'
    }

    // 将插件信息添加到菜单
    this.menus.push(pluginInfo)

    // 更新分类信息
    this.updateCategories()

    // 保存菜单配置
    await this.saveMenuConfig()

    return true
  }

  // 设置插件配置项
  async setPluginConfig(pluginName, configKey, value, defaultValue = null) {
    // 确保配置已加载
    if (!this.config) {
      await this.loadConfig()
    }

    // 如果未提供值且有默认值，则使用默认值
    if (value === undefined && defaultValue !== null) {
      value = defaultValue
    }

    // 确保插件配置对象存在
    if (!this.config.plugins) {
      this.config.plugins = {}
    }
    if (!this.config.plugins[pluginName]) {
      this.config.plugins[pluginName] = {}
    }

    // 更新配置
    this.config.plugins[pluginName][configKey] = value

    // 保存配置
    await this.saveMenuConfig()

    return value
  }

  // 获取插件配置项
  async getPluginConfig(pluginName, configKey, defaultValue = null) {
    // 确保配置已加载
    if (!this.config) {
      await this.loadConfig()
    }

    // 如果配置不存在，返回默认值
    if (!this.config.plugins || !this.config.plugins[pluginName] || this.config.plugins[pluginName][configKey] === undefined) {
      return defaultValue
    }

    return this.config.plugins[pluginName][configKey]
  }

  // 简化的配置接口 - 一行代码获取配置（自动处理默认值）
  async getConfig(pluginName, configKey, defaultValue = null) {
    // 确保配置已加载
    if (!this.config) {
      await this.loadConfig()
    }

    // 确保插件配置对象存在
    if (!this.config.plugins) {
      this.config.plugins = {}
    }
    if (!this.config.plugins[pluginName]) {
      this.config.plugins[pluginName] = {}
    }

    // 如果配置不存在，设置并返回默认值，并自动保存
    let isModified = false
    if (this.config.plugins[pluginName][configKey] === undefined && defaultValue !== null) {
      this.config.plugins[pluginName][configKey] = defaultValue
      isModified = true
    }

    // 保存修改
    if (isModified) {
      await this.saveMenuConfig()
    }

    return this.config.plugins[pluginName][configKey] || defaultValue
  }

  // 更新分类信息
  updateCategories() {
    this.categories = {}
  let globalIndex = 1

  // 初始化默认分类
  this.categories['功能'] = []
  this.categories['小游戏'] = []

  // 将插件按分类整理，并分配全局索引
  for (const plugin of this.menus) {
    const category = plugin.category || '功能'
    if (!this.categories[category]) {
      this.categories[category] = []
    }
    // 为插件添加全局索引
    plugin.globalIndex = globalIndex++
      this.categories[category].push(plugin)
    }
  }

  // 保存菜单配置
  async saveMenuConfig() {
    try {
      const yaml = await import('yaml')
      // 先读取当前配置文件内容
      let existingConfig = {}
      try {
        const configStr = await fs.readFile(configPath, 'utf8')
        existingConfig = yaml.parse(configStr)
      } catch (error) {
        // 静默处理配置读取失败，不输出日志
        existingConfig = {}
      }

      // 确保config对象存在
      if (!this.config) {
        this.config = {}
      }

      // 合并配置: 保留现有配置，更新menus和plugins部分
      const mergedConfig = {
        ...existingConfig,
        menus: this.menus,
        plugins: {
          ...(existingConfig.plugins || {}),
          ...(this.config.plugins || {})
        }
      }

      const configStr = yaml.stringify(mergedConfig)
      await fs.writeFile(configPath, configStr, 'utf8')
      // 移除成功日志
    } catch (error) {
      // 移除错误日志
      // console.error('保存菜单配置失败')
    }
  }
}

export default new MenuManager()